// index.js
const app = getApp()
const config = require('../../utils/config')
const api = require('../../utils/api')

Page({
  data: {
    banners: [],                 // 轮播图数据
    recommendProducts: [],       // 推荐商品数据
    loading: true,               // 加载状态
    errorMessage: '',            // 错误信息
    
    // 搜索相关数据
    searchKeyword: '',           // 搜索关键词
    searchSuggestions: [],       // 搜索推荐关键词
    showSuggestions: false,      // 是否显示搜索推荐
    hotKeywords: ['手机', '笔记本', '女装', '男鞋', '耳机'],  // 热门搜索词
    searchTimer: null,           // 搜索延迟定时器
  },
  
  onLoad() {
    console.log('首页 onLoad')
    this.loadData()
  },
  
  onShow() {
    console.log('首页 onShow')
    
    // 更新tabBar选中状态
    if (typeof this.getTabBar === 'function') {
      this.getTabBar().setData({
        selected: 0
      })
    }
    
    // 添加事件监听，点击页面任何位置关闭搜索推荐
    this.closeSearchSuggestionsListener = () => {
      if (this.data.showSuggestions) {
        this.setData({ showSuggestions: false })
      }
    }
  },
  
  onReady() {
    console.log('首页 onReady')
  },
  
  onPullDownRefresh() {
    // 下拉刷新
    this.loadData(() => {
      wx.stopPullDownRefresh() // 停止下拉刷新动画
    })
  },
  
  // 加载所有数据
  loadData(callback) {
    this.setData({ 
      loading: true,
      errorMessage: ''
    })
    
    // 并行请求轮播图和推荐商品数据
    Promise.all([
      this.fetchBanners(),
      this.fetchRecommendProducts()
    ])
      .then(() => {
        this.setData({ loading: false })
        callback && callback()
      })
      .catch(err => {
        console.error('数据加载失败', err)
        this.setData({ 
          loading: false,
          errorMessage: '加载失败，点击下拉刷新重试'
        })
        callback && callback()
      })
  },
  
  // 获取轮播图数据
  fetchBanners() {
    // 构建完整URL，方便调试
    const fullUrl = `${config.API_BASE_URL}${config.API.HOME.BANNER}`
    console.log('请求轮播图数据, URL:', fullUrl)
    
    return new Promise((resolve, reject) => {
      api.get(config.API.HOME.BANNER)
        .then(res => {
          console.log('获取轮播图成功:', res)
          
          // 确保返回的是数组
          let banners = []
          if (res.data && Array.isArray(res.data)) {
            banners = res.data
          } else if (res.data && res.data.list && Array.isArray(res.data.list)) {
            banners = res.data.list
          } else if (res.data && typeof res.data === 'object') {
            // 尝试将对象转为数组
            const objData = res.data
            if (Object.keys(objData).length > 0) {
              banners = Object.keys(objData).map(key => objData[key])
            }
          }
          
          console.log('处理前的轮播图数据:', banners)
          
          // 确保每个轮播图都有有效的图片URL
          banners = banners.map(banner => {
            // 调试输出
            console.log('处理轮播图项:', banner)
            
            // 如果已经是本地路径，保持不变
            if (banner.image && banner.image.startsWith('/')) {
              return banner
            }
            
            // 如果是http路径，检查是否完整
            if (banner.image && banner.image.indexOf('http') === 0) {
              return banner
            }
            
            // 检查是否有其他图片字段
            if (!banner.image && banner.img) {
              return {...banner, image: banner.img}
            }
            
            if (!banner.image && banner.pic) {
              return {...banner, image: banner.pic}
            }
            
            return banner
          })
          
          console.log('处理后的轮播图数据:', banners)
          
          if (banners.length === 0) {
            this.setData({
              errorMessage: '暂无轮播图数据'
            })
          } else {
            this.setData({ banners })
          }
          resolve(banners)
        })
        .catch(err => {
          console.error('获取轮播图失败:', err)
          this.setData({
            errorMessage: '获取轮播图数据失败'
          })
          // 不使用默认数据，直接返回空数组
          reject(err)
        })
    })
  },
  
  // 获取推荐商品
  fetchRecommendProducts() {
    // 构建完整URL，方便调试
    const fullUrl = `${config.API_BASE_URL}${config.API.PRODUCT.RECOMMEND}`
    console.log('请求推荐商品数据, URL:', fullUrl)
    
    return new Promise((resolve, reject) => {
      api.get(config.API.PRODUCT.RECOMMEND)
        .then(res => {
          console.log('获取推荐商品成功:', res)
          
          // 确保返回的是数组
          let products = []
          if (res.data && Array.isArray(res.data)) {
            products = res.data
          } else if (res.data && res.data.list && Array.isArray(res.data.list)) {
            products = res.data.list
          } else if (res.data && typeof res.data === 'object') {
            // 尝试将对象转为数组
            const objData = res.data
            if (Object.keys(objData).length > 0) {
              products = Object.keys(objData).map(key => objData[key])
            }
          }
          
          // 处理产品数据，确保字段名称一致
          products = products.map(product => {
            const processedProduct = { ...product }
            
            // 确保每个产品都有id字段
            if (!processedProduct.id && processedProduct.productId) {
              processedProduct.id = processedProduct.productId
            }
            
            // 确保每个产品都有cover字段
            if (!processedProduct.cover && processedProduct.image) {
              processedProduct.cover = processedProduct.image
            } else if (!processedProduct.cover && processedProduct.coverImage) {
              processedProduct.cover = processedProduct.coverImage
            }
            
            // 确保有名称
            if (!processedProduct.name && processedProduct.title) {
              processedProduct.name = processedProduct.title
            }
            
            return processedProduct
          })
          
          if (products.length === 0) {
            this.setData({
              errorMessage: '暂无推荐商品数据'
            })
          } else {
            this.setData({ recommendProducts: products })
          }
          resolve(products)
        })
        .catch(err => {
          console.error('获取推荐商品失败:', err)
          this.setData({
            errorMessage: '获取推荐商品数据失败'
          })
          // 不使用默认数据，直接返回空数组
          reject(err)
        })
    })
  },
  
  // 搜索框输入事件
  onSearchInput(e) {
    const keyword = e.detail.value
    this.setData({ searchKeyword: keyword })
    
    // 清除之前的定时器
    if (this.data.searchTimer) {
      clearTimeout(this.data.searchTimer)
    }
    
    // 如果关键词为空，隐藏推荐
    if (!keyword || keyword.trim() === '') {
      this.setData({ 
        showSuggestions: false,
        searchSuggestions: []
      })
      return
    }
    
    // 设置新的定时器，延迟300ms再搜索，避免频繁请求
    const timer = setTimeout(() => {
      this.getSearchSuggestions(keyword)
    }, 300)
    
    this.setData({ searchTimer: timer })
  },
  
  // 获取搜索推荐关键词
  getSearchSuggestions(keyword) {
    // 优先使用热门关键词中包含输入词的结果
    let suggestions = this.data.hotKeywords.filter(item => 
      item.toLowerCase().includes(keyword.toLowerCase())
    )
    
    // 如果推荐数量不足5个，可以调用接口获取更多推荐
    // 这里为了简化，如果热门词中没有足够的匹配项，就直接使用前5个热门词
    if (suggestions.length < 5) {
      // 添加一些和输入词相关的伪造推荐
      const additionalSuggestions = [
        keyword + '热卖', 
        keyword + '新品',
        '限量版' + keyword,
        '正品' + keyword,
        keyword + '推荐'
      ].slice(0, 5 - suggestions.length)
      
      suggestions = [...suggestions, ...additionalSuggestions]
      // 限制最多5个推荐
      suggestions = suggestions.slice(0, 5)
    }
    
    // 如果要调用后端接口获取搜索推荐，可以使用如下代码：
    /*
    api.get('/search/suggest', { keyword: keyword })
      .then(res => {
        const suggestions = res.data || []
        this.setData({
          searchSuggestions: suggestions.slice(0, 5), // 最多5个
          showSuggestions: suggestions.length > 0
        })
      })
      .catch(err => {
        console.error('获取搜索推荐失败:', err)
      })
    */
    
    this.setData({
      searchSuggestions: suggestions,
      showSuggestions: suggestions.length > 0
    })
  },
  
  // 清除搜索关键词
  clearSearchKeyword() {
    this.setData({
      searchKeyword: '',
      showSuggestions: false
    })
  },
  
  // 使用推荐关键词
  useSuggestion(e) {
    const keyword = e.currentTarget.dataset.keyword
    this.setData({
      searchKeyword: keyword,
      showSuggestions: false
    })
    // 立即执行搜索
    this.onSearchConfirm({ detail: { value: keyword } })
  },
  
  // 搜索确认事件（按下回车键）
  onSearchConfirm(e) {
    const keyword = e.detail.value
    if (!keyword || keyword.trim() === '') {
      return
    }
    
    // 保存搜索历史
    this.saveSearchHistory(keyword)
    
    // 隐藏推荐
    this.setData({ showSuggestions: false })
    
    // 跳转到搜索结果页面，携带关键词参数
    wx.navigateTo({
      url: `/pages/search/index?keyword=${keyword}`
    })
  },
  
  // 保存搜索历史
  saveSearchHistory(keyword) {
    let history = wx.getStorageSync('historyKeywords') || []
    
    // 如果已存在，则移除
    const index = history.indexOf(keyword)
    if (index !== -1) {
      history.splice(index, 1)
    }
    
    // 添加到开头
    history.unshift(keyword)
    
    // 限制数量，最多保存10条
    if (history.length > 10) {
      history = history.slice(0, 10)
    }
    
    // 保存到本地存储
    wx.setStorageSync('historyKeywords', history)
  },
  
  // 商品点击，跳转到商品详情页
  handleProductClick(e) {
    const productId = e.currentTarget.dataset.id
    wx.navigateTo({
      url: `/pages/product/detail/detail?id=${productId}`,
    })
  },
  
  // 查看更多推荐商品
  handleViewMore() {
    wx.switchTab({
      url: '/pages/category/index',
    })
  },
  
  // 广告点击
  handleBannerClick(e) {
    const banner = e.currentTarget.dataset.item
    
    // 根据banner类型跳转不同页面
    if (!banner || !banner.id) {
      return
    }
    
    // 根据banner上配置的链接类型跳转
    if (banner.linkType === 'product' && banner.linkId) {
      // 跳转到商品详情
      wx.navigateTo({
        url: `/pages/product/detail/detail?id=${banner.linkId}`
      })
    } else if (banner.linkType === 'category' && banner.linkId) {
      // 跳转到分类页
      wx.navigateTo({
        url: `/pages/product/list/list?categoryId=${banner.linkId}&categoryName=${encodeURIComponent(banner.title || '商品列表')}`
      })
    } else if (banner.linkUrl) {
      // 跳转到web页面
      wx.navigateTo({
        url: `/pages/webview/index?url=${encodeURIComponent(banner.linkUrl)}`
      })
    } else {
      console.log('轮播图点击，但未设置跳转目标', banner)
    }
  },
  
  handleRefresh() {
    this.loadData()
  },
  
  // 添加到购物车
  handleAddToCart(e) {
    const product = e.currentTarget.dataset.item
    console.log('添加到购物车', product)
    
    // 检查并获取token
    const token = wx.getStorageSync('token')
    console.log('当前token:', token)
    
    // 如果没有token，提示登录
    if (!token) {
      wx.showModal({
        title: '提示',
        content: '请先登录',
        success(res) {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/my/index'
            })
          }
        }
      })
      return
    }
    
    // 校验商品信息
    if (!product || !product.id) {
      wx.showToast({
        title: '商品信息不完整',
        icon: 'none'
      })
      return
    }
    
    // 显示加载提示
    wx.showLoading({
      title: '添加中...',
      mask: true
    })
    
    console.log('开始调用购物车API, 商品ID:', product.id)
    
    // 使用api模块调用添加购物车接口
    api.post(config.API.CART.ADD, {
      productId: product.id,
      quantity: 1
    })
    .then(res => {
      wx.hideLoading()
      console.log('添加购物车结果:', res)
      
      if (res.code === 200) {
        wx.showToast({
          title: '已加入购物车',
          icon: 'success'
        })
        
        // 更新购物车角标
        this.updateCartBadge()
      } else {
        wx.showToast({
          title: res.message || '添加失败',
          icon: 'none'
        })
      }
    })
    .catch(err => {
      wx.hideLoading()
      console.error('添加购物车请求失败', err)
      
      // 判断是否是token无效错误
      if (err && err.code === 401) {
        // token无效，清除并重新登录
        wx.removeStorageSync('token')
        wx.showModal({
          title: '登录已过期',
          content: '请重新登录',
          success(res) {
            if (res.confirm) {
              wx.navigateTo({
                url: '/pages/my/index'
              })
            }
          }
        })
      } else {
        wx.showToast({
          title: err.message || '网络请求失败',
          icon: 'none'
        })
      }
    })
  },
  
  // 更新购物车角标
  updateCartBadge() {
    const token = wx.getStorageSync('token')
    if (!token) return
    
    api.get(config.API.CART.COUNT)
      .then(res => {
        const count = res.data || 0
        if (count > 0) {
          wx.setTabBarBadge({
            index: 2,
            text: '' + count
          })
        } else {
          wx.removeTabBarBadge({
            index: 2
          })
        }
      })
      .catch(err => {
        console.error('获取购物车数量失败', err)
      })
  },
  
  // 在onUnload方法中清除定时器
  onUnload() {
    // 清除搜索定时器，防止内存泄漏
    if (this.data.searchTimer) {
      clearTimeout(this.data.searchTimer)
    }
  },
  
  // 修复onHide方法
  onHide() {
    // 清除搜索定时器
    if (this.data.searchTimer) {
      clearTimeout(this.data.searchTimer)
    }
    // 如果有需要在页面隐藏时处理的逻辑，可以在这里添加
    this.closeSearchSuggestionsListener = null
  },
  
  // 搜索框点击事件，阻止冒泡
  onSearchBoxClick(e) {
    // 阻止事件冒泡，防止触发外层的关闭搜索推荐
    // 在微信小程序中，使用catchtap替代bindtap已经阻止了事件冒泡
    // 不需要额外调用stopPropagation
    console.log('搜索框被点击')
  }
})
